home *** CD-ROM | disk | FTP | other *** search
/ PsL Monthly 1993 December / PSL Monthly Shareware CD-ROM (December 1993).iso / prgmming / dos / c / snippet.exe / PRNSPOOL.C < prev    next >
Encoding:
C/C++ Source or Header  |  1992-05-31  |  3.2 KB  |  154 lines
  1. /* prnspool.c 12-22-91 Robert Mashlan, public domain */
  2. /* DOS print spooler interface functions             */
  3.  
  4. #include <stdio.h>
  5. #include <dos.h>
  6.  
  7. int printspool_errno = 0;
  8.  
  9. char *printspool_errlist[] = {
  10.       "No error",
  11.       "Function Invalid",
  12.       "File not found",
  13.       "Path not found",
  14.       "Too many open files",
  15.       "Access denied",
  16.       "",
  17.       "",
  18.       "Queue full",
  19.       "Spooler busy",
  20.       "",
  21.       "",
  22.       "Name too long",
  23.       "",
  24.       "Drive invalid"
  25.       };
  26.  
  27. /* returns -1 if printspooler installed */
  28. /* 0 otherwise                          */
  29.  
  30. int printspool_installed(void)
  31. {
  32.       union REGS r;
  33.  
  34.       r.x.ax = 0x0100;
  35.       int86(0x2f, &r, &r);
  36.       if(r.h.al==0xff)
  37.       {
  38.             printspool_errno=0;
  39.             return -1;
  40.       }
  41.       else
  42.       {
  43.             printspool_errno=1;
  44.             return 0;
  45.       }
  46. }
  47.  
  48. /* submits a file name to be printed */
  49. /* returns error code                */
  50.  
  51. int printspool_submit( const char *pathname )
  52. {
  53.       struct {
  54.             unsigned char level;
  55.             char far *pathname;
  56.             } packet;
  57.       union REGS r;
  58.       struct SREGS s;
  59.  
  60.       packet.level = 0;
  61.       packet.pathname = (char far *)pathname;
  62.       s.ds   = FP_SEG(&packet);
  63.       r.x.dx = FP_OFF(&packet);
  64.       r.x.ax = 0x0101;
  65.       int86x(0x2f, &r, &r, &s);
  66.       if(!r.x.cflag)
  67.             return printspool_errno = 0;
  68.       else  return printspool_errno = r.x.ax;
  69. }
  70.  
  71. /* removes a file from the print queue */
  72.  
  73. int printspool_remove( const char far *fname )
  74. {
  75.       union REGS r;
  76.       struct SREGS s;
  77.  
  78.       s.ds   = FP_SEG(fname);
  79.       r.x.dx = FP_OFF(fname);
  80.       r.x.ax = 0x0102;
  81.       int86x(0x2f, &r, &r, &s);
  82.       if(!r.x.cflag)
  83.             return printspool_errno = 0;
  84.       else  return printspool_errno=r.x.ax;
  85. }
  86.  
  87. /* cancels all files in the print queue */
  88.  
  89. int printspool_cancel(void)
  90. {
  91.       union REGS r;
  92.  
  93.       r.x.ax = 0x0103;
  94.       int86(0x2f, &r, &r);
  95.       if(!r.x.cflag)
  96.             return printspool_errno = 0;
  97.       else  return printspool_errno = r.x.ax;
  98. }
  99.  
  100. /* ends hold state after a call to printspool_qetqueue */
  101. /* or printspool_errorcount                            */
  102.  
  103. void printspool_endhold(void)
  104. {
  105.       union REGS r;
  106.  
  107.       r.x.ax = 0x0105;
  108.       int86(0x2f, &r, &r);
  109. }
  110.  
  111. /* returns a far pointer to the printspooler queue, */
  112. /* an array of 64 char asciiz strings               */
  113.  
  114. char far *printspool_getqueue(void)
  115. {
  116.       char far *result;
  117.       union REGS r;
  118.       struct SREGS s;
  119.  
  120.       r.x.ax = 0x0104;
  121.       int86x(0x2f, &r, &r, &s);
  122.       result = MK_FP(s.ds,r.x.si);
  123.       if (!r.x.cflag)
  124.       {
  125.             printspool_errno = 0;
  126.             return result;
  127.       }
  128.       else
  129.       {
  130.             printspool_errno = r.x.ax;
  131.             return NULL;
  132.       }
  133. }
  134.  
  135. /* returns the error count from the printspooler */
  136.  
  137. int printspool_errorcount(void)
  138. {
  139.       union REGS r;
  140.  
  141.       r.x.ax = 0x0104;
  142.       int86(0x2f, &r, &r);
  143.       if (!r.x.cflag)
  144.       {
  145.             printspool_errno = 0;
  146.             return r.x.dx;          /* return the number of errors */
  147.       }
  148.       else
  149.       {
  150.             printspool_errno = r.x.ax;
  151.             return r.x.dx;
  152.       }
  153. }
  154.